Tree-based Algorithm to Find the k-th Value in Distributed Systems

In this paper, we study distributed algorithms for finding the k-th value in the decentralized systems. First we consider the case of circular configuration of processors where no processor knows the total number of participants. Later a network of arbitrary configuration is examined and a tree-based algorithm is proposed. The proposed algorithm requires O(N) messages and O(log N) rounds of message passing, where N is the number of nodes in the network

Gentle Introduction to Larch / Smalltalk Specification Browsers

This paper provides a tutorial introduction to the Larch/Smalltalk specification browsers. The browsers are specification support tools providing a powerful and sophisticated environment for writing and managing Larch/Smalltalk specifications. They are integrated in the Smalltalk-80 programming system. The reader is assumed to have some familiarity with the Smalltalk system and Larch-style specification

The Larch/Smalltalk Interface Specification Language

Object-oriented programming languages, such as Smalltalk, help one to build reusable program modules. The reuse of program modules requires adequate documentation --- formal or informal. Larch/Smalltalk is a formal specification language for specifying such reusable Smalltalk modules. Larch/Smalltalk firmly separates specification from implementation. In Larch/Smalltalk, the unit of specification is an abstract data type, which is an abstraction of the behavior produced by one or more Smalltalk classes. A type can be a subtype of other types, which allows types to be organized based on specified behavior, and also allows for inheritance of their specifications. Larch/Smalltalk specifications are developed using specification tools integrated in the Smalltalk programming environment

Toward Unification of Explicit and Implicit Invocation-Style Programming

Subprograms like procedures and methods can be invoked explicitly or implicitly; in implicit invocation, an event implicitly causes the invocation of subprograms that are registered an interest in the event. Mixing these two styles is common in programming and often unavoidable in developing such software as GUI applications and event-based control systems. However, it isn\u27t also uncommon for the mixed use to complicate programming logic and thus produce unclean code, code that is hard to read and understand. We show, through a small but realistic example, that the problem is not much on mixing two different styles itself but more on using them in an unconstrained manner. We propose a few principles or guidelines for unifying the two styles harmoniously and also describe a simple, proof-of-concept framework for converting one style to the other for the unification. Our work enables one to blend the two different invocation styles harmoniously and in a properly constrained fashion to produce clean code

Larch/Smalltalk: A Specification Language for Smalltalk

Larch/Smalltalk is a Larch interface specification language for Smalltalk with subtype relations. As a Larch-style language it benefits from two-tiered approach to specifications; separation of concerns, division of effort, and reusability. Subtype relationships helps to reuse and modularize specifications. A unit of specification in Larch/Smalltalk is called a type, which describes an abstraction of a set of Smalltalk classes. Complex specifications can be constructed by defining a type to be a subtype of other types, called its supertypes, thereby, inheriting their specifications. Specifications can also be parameterized to specify a family of related types. To encourage specifications to be used in the programming process, specification development tools have been implemented in Smalltalk. They are integrated in the Smalltalk-80 system. Using these tools, a portion of Smalltalk system classes and a part of the tools themselves have been specified.</p